/**
 * libpsd - Photoshop file formats (*.psd) decode library
 * Copyright (C) 2004-2007 Graphest Software.
 *
 * libpsd is the legal property of its developers, whose names are too numerous
 * to list here.  Please refer to the COPYRIGHT file distributed with this
 * source distribution.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * $Id: levelsl.c, created by Patrick in 2006.05.22, libpsd@graphest.com Exp $
 */

#include <math.h>
#include "libpsd.h"
#include "psd_system.h"
#include "psd_stream.h"
#include "psd_color.h"
#include "psd_rect.h"
#include "psd_math.h"


extern void psd_adjustment_blend_rgb(psd_context * context, psd_layer_record * layer, psd_rect * dst_rect, 
    psd_uchar * red_lookup_table, psd_uchar * green_lookup_table, psd_uchar * blue_lookup_table,
    psd_bool preserve_luminosity);


// Additional layer -- levels
// Levels settings files are loaded and saved in the Levels dialog.
psd_status psd_get_layer_levels(psd_context * context, psd_layer_record * layer, psd_int data_length)
{
    psd_layer_levels * data;
    psd_int i, prev_stream_pos = context->stream.current_pos;
    psd_uint tag;
    
    layer->layer_info_type[layer->layer_info_count] = psd_layer_info_type_levels;
    layer->layer_type = psd_layer_type_levels;

    data = (psd_layer_levels *)psd_malloc(sizeof(psd_layer_levels));
    if(data == NULL)
        return psd_status_malloc_failed;
    memset(data, 0, sizeof(psd_layer_levels));
    layer->layer_info_data[layer->layer_info_count] = (psd_uint)data;
    layer->layer_info_count ++;
    
    // Version ( = 2)
    if(psd_stream_get_short(context) != 2)
        return psd_status_levels_unsupport_version;

    // 29 sets of level records, each level containing 5 psd_short integers
    for(i = 0; i < 29; i ++)
    {
        // Input floor (0...253)
        data->record[i].input_floor = psd_stream_get_short(context);
        // Input ceiling (2...255)
        data->record[i].input_ceiling = psd_stream_get_short(context);
        // Output floor (0...255). Matched to input floor.
        data->record[i].output_floor = psd_stream_get_short(context);
        // Output ceiling (0...255)
        data->record[i].output_ceiling = psd_stream_get_short(context);
        // Gamma. Short integer from 10...999 representing 0.1...9.99. Applied
        // to all image data.
        data->record[i].gamma = psd_stream_get_short(context) / 100.0f;
        // Sets 28 and 29 are reserved and should be set to zeros.
        if(i < 27)
        {
            psd_assert(data->record[i].input_floor >= 0 && data->record[i].input_floor <= 255);
            psd_assert(data->record[i].input_ceiling >= 2 && data->record[i].input_ceiling <= 255);
            psd_assert(data->record[i].output_floor >= 0 && data->record[i].output_floor <= 255);
            psd_assert(data->record[i].output_ceiling >= 0 && data->record[i].output_ceiling <= 255);
            psd_assert(data->record[i].gamma >= 0.1 && data->record[i].gamma <= 9.99);
        }
    }

    // Photoshop CS (8.0) Additional information
    // At the end of the Version 2 file is the following information
    if(context->stream.current_pos - prev_stream_pos < data_length - 4)
    {
        // = 'Lvls' for extra level information
        tag = psd_stream_get_int(context);
        if(tag != 'Lvls')
            return psd_status_extra_levels_key_error;

        // Version ( = 3)
        if(psd_stream_get_short(context) != 3)
            return psd_status_extra_levels_unsupport_version;

        // Count of total level record structures. Subtract the legacy number of
        // level record structures, 29, to determine how many are remaining in
        // the file for reading.
        data->extra_level_count = psd_stream_get_short(context) - 29;
        psd_assert(data->extra_level_count >= 0);
        data->extra_record = (psd_layer_level_record *)psd_malloc(data->extra_level_count * sizeof(psd_layer_level_record));
        if(data->extra_record == NULL)
            return psd_status_malloc_failed;
        memset(data->extra_record, 0, data->extra_level_count * sizeof(psd_layer_level_record));

        // Additianol level records according to count.
        for(i = 0; i < data->extra_level_count; i ++)
        {
            // Input floor (0...253)
            data->extra_record[i].input_floor = psd_stream_get_short(context);
            // Input ceiling (2...255)
            data->extra_record[i].input_ceiling = psd_stream_get_short(context);
            // Output floor (0...255). Matched to input floor.
            data->extra_record[i].output_floor = psd_stream_get_short(context);
            // Output ceiling (0...255)
            data->extra_record[i].output_ceiling = psd_stream_get_short(context);
            // Gamma. Short integer from 10...999 representing 0.1...9.99. Applied
            // to all image data.
            data->extra_record[i].gamma = psd_stream_get_short(context) / 100.0f;
            // Sets 28 and 29 are reserved and should be set to zeros.
        }
    }

    if(context->stream.current_pos - prev_stream_pos != data_length)
        return psd_status_levels_dismatch_data_length;

    layer->adjustment_valid = psd_true;

    return psd_status_done;
}

void psd_layer_levels_free(psd_uint info_data)
{
    psd_layer_levels * data;

    data = (psd_layer_levels *)info_data;
    psd_freeif(data->extra_record);
    psd_free(data);
}

psd_bool psd_layer_blend_levels(psd_context * context, psd_layer_record * layer, psd_rect * dst_rect)
{
    psd_int i, j, range, floor, value;
    psd_float gamma;
    psd_layer_levels * data = NULL;
    psd_uchar input_table[256], output_table[256];

    if(context->color_mode != psd_color_mode_rgb && context->color_mode != psd_color_mode_grayscale)
        return psd_false;

    for(i = 0; i < layer->layer_info_count; i ++)
    {
        if(layer->layer_info_type[i] == psd_layer_info_type_levels)
        {
            data = (psd_layer_levels *)layer->layer_info_data[i];
            break;
        }
    }
    if(data == NULL)
        return psd_false;

    if(layer->adjustment_valid == psd_true)
    {
        for(i = 0; i < 3; i ++)
        {
            for(j = 0; j < 256; j ++)
                data->lookup_table[i][j] = j;
        }
        for(i = 0; i < 4; i ++)
        {
            if(data->record[i].input_floor != 0 || data->record[i].input_ceiling != 255 ||
                data->record[i].output_floor != 0 || data->record[i].output_ceiling != 255 ||
                data->record[i].gamma != 1.0)
            {
                if(layer->adjustment_valid == psd_true)
                {
                    if(data->record[i].input_floor != 0 || data->record[i].input_ceiling != 255 ||
                        data->record[i].gamma != 1.0)
                    {
                        range = data->record[i].input_ceiling - data->record[i].input_floor;
                        floor = data->record[i].input_floor;
                        if(data->record[i].gamma != 1.0)
                        {
                            gamma = 1 / data->record[i].gamma;
                            for(j = 0; j < 256; j ++)
                            {
                                value = (psd_int)(pow((psd_float)(j - floor) / range, gamma) * 255 + 0.5);
                                input_table[j] = PSD_CONSTRAIN(value, 0, 255);
                            }
                        }
                        else
                        {
                            for(j = 0; j < 256; j ++)
                            {
                                value = (psd_int)((j - floor) * 255.0 / range);
                                input_table[j] = PSD_CONSTRAIN(value, 0, 255);
                            }
                        }
                    }
                    else
                    {
                        for(j = 0; j < 256; j ++)
                            input_table[j] = j;
                    }

                    if(data->record[i].output_floor != 0 || data->record[i].output_ceiling != 255)
                    {
                        range = data->record[i].output_ceiling - data->record[i].output_floor;
                        floor = data->record[i].output_floor;
                        for(j = 0; j < 256; j ++)
                        {
                            output_table[j] = (j * range + 128) / 255 + floor;
                        }
                    }
                    else
                    {
                        for(j = 0; j < 256; j ++)
                            output_table[j] = j;
                    }

                    if(i == 0)
                    {
                        for(j = 0; j < 256; j ++)
                        {
                            data->lookup_table[0][j] = data->lookup_table[1][j] = 
                                data->lookup_table[2][j] = output_table[input_table[j]];
                        }
                    }
                    else
                    {
                        for(j = 0; j < 256; j ++)
                            data->lookup_table[i - 1][j] = output_table[input_table[data->lookup_table[i - 1][j]]];
                    }
                }
            }
            
            if(context->color_mode == psd_color_mode_grayscale)
                break;
        }
    }
    
    psd_adjustment_blend_rgb(context, layer, dst_rect, data->lookup_table[0],
        data->lookup_table[1], data->lookup_table[2], psd_false);

    layer->adjustment_valid = psd_false;

    return psd_true;
}

